home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / octa209b.zip / octave-2.09 / DLFCN.ZIP / dlfcn / examples / make_int.cc < prev    next >
C/C++ Source or Header  |  1997-01-12  |  10KB  |  375 lines
  1. /*
  2.  
  3. Copyright (C) 1996 John W. Eaton
  4.  
  5. This file is part of Octave.
  6.  
  7. Octave is free software; you can redistribute it and/or modify it
  8. under the terms of the GNU General Public License as published by the
  9. Free Software Foundation; either version 2, or (at your option) any
  10. later version.
  11.  
  12. Octave is distributed in the hope that it will be useful, but WITHOUT
  13. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15. for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with Octave; see the file COPYING.  If not, write to the Free
  19. Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20.  
  21. */
  22.  
  23. /* Modified by Klaus Gebhardt, 1996 */
  24.  
  25. #include <octave/config.h>
  26.  
  27. #include <cstdlib>
  28.  
  29. #include <string>
  30.  
  31. class ostream;
  32.  
  33. #include <octave/lo-utils.h>
  34. #include <octave/mx-base.h>
  35. #include <octave/str-vec.h>
  36.  
  37. #include <octave/defun-dld.h>
  38. #include <octave/error.h>
  39. #include <octave/gripes.h>
  40. #include <octave/mappers.h>
  41. #include <octave/oct-obj.h>
  42. #include <octave/ops.h>
  43. #include <octave/ov-base.h>
  44. #include <octave/ov-typeinfo.h>
  45. #include <octave/ov.h>
  46. #include <octave/ov-scalar.h>
  47. #include <octave/pager.h>
  48. #include <octave/pr-output.h>
  49. #include <octave/symtab.h>
  50. #include <octave/variables.h>
  51.  
  52. class Octave_map;
  53. class octave_value_list;
  54.  
  55. class tree_walker;
  56.  
  57. // Integer values.
  58.  
  59. class
  60. octave_integer : public octave_base_value
  61. {
  62. public:
  63.  
  64.   octave_integer (void)
  65.     : octave_base_value (), scalar (0) { }
  66.  
  67.   octave_integer (int i)
  68.     : octave_base_value (), scalar (i) { }
  69.  
  70.   octave_integer (const octave_integer& s)
  71.     : octave_base_value (), scalar (s.scalar) { }
  72.  
  73.   ~octave_integer (void) { }
  74.  
  75.   octave_value *clone (void) { return new octave_integer (*this); }
  76.  
  77. #if 0
  78.   void *operator new (size_t size);
  79.   void operator delete (void *p, size_t size);
  80. #endif
  81.  
  82.   idx_vector index_vector (void) const { return idx_vector ((double) scalar); }
  83.  
  84.   int rows (void) const { return 1; }
  85.   int columns (void) const { return 1; }
  86.  
  87.   bool is_defined (void) const { return true; }
  88.   bool is_real_scalar (void) const { return true; }
  89.  
  90.   octave_value all (void) const { return (scalar != 0); }
  91.   octave_value any (void) const { return (scalar != 0); }
  92.  
  93.   bool is_real_type (void) const { return true; }
  94.   bool is_scalar_type (void) const { return true; }
  95.   bool is_numeric_type (void) const { return true; }
  96.  
  97.   bool valid_as_scalar_index (void) const
  98.     { return scalar == 1; }
  99.  
  100.   bool valid_as_zero_index (void) const
  101.     { return scalar == 0; }
  102.  
  103.   bool is_true (void) const { return (scalar != 0); }
  104.  
  105.   double double_value (bool = false) const { return (double) scalar; }
  106.  
  107.   int integer_value (bool = false) const { return scalar; }
  108.  
  109.   Matrix matrix_value (bool = false) const { return Matrix (1, 1, scalar); }
  110.  
  111.   Complex complex_value (bool = false) const { return scalar; }
  112.  
  113.   ComplexMatrix complex_matrix_value (bool = false) const
  114.     { return  ComplexMatrix (1, 1, Complex (scalar)); }
  115.  
  116.   octave_value not (void) const { return octave_value (! scalar); }
  117.  
  118.   octave_value uminus (void) const { return octave_value (- scalar); }
  119.  
  120.   octave_value transpose (void) const { return octave_value (scalar); }
  121.  
  122.   octave_value hermitian (void) const { return octave_value (scalar); }
  123.  
  124.   void increment (void) { ++scalar; }
  125.  
  126.   void decrement (void) { --scalar; }
  127.  
  128.   void print (ostream& os, bool pr_as_read_syntax = false);
  129.  
  130.   int type_id (void) const { return t_id; }
  131.  
  132.   string type_name (void) const { return t_name; }
  133.  
  134.   static int static_type_id (void) { return t_id; }
  135.  
  136.   static void register_type (void)
  137.     { t_id = octave_value_typeinfo::register_type (t_name); }
  138.  
  139. private:
  140.  
  141.   int scalar;
  142.  
  143.   static int t_id;
  144.  
  145.   static const string t_name;
  146. };
  147.  
  148. int octave_integer::t_id = -1;
  149.  
  150. const string octave_integer::t_name ("integer");
  151.  
  152. void
  153. octave_integer::print (ostream& os, bool pr_as_read_syntax)
  154. {
  155.   octave_print_internal (os, scalar, pr_as_read_syntax);
  156. }
  157.  
  158. // integer by integer ops.
  159.  
  160. static octave_value
  161. add (const octave_value& a1, const octave_value& a2)
  162. {
  163.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  164.  
  165.   return new octave_integer (v1.integer_value () + v2.integer_value ());
  166. }
  167.  
  168. static octave_value
  169. sub (const octave_value& a1, const octave_value& a2)
  170. {
  171.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  172.  
  173.   return new octave_integer (v1.integer_value () - v2.integer_value ());
  174. }
  175.  
  176. static octave_value
  177. mul (const octave_value& a1, const octave_value& a2)
  178. {
  179.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  180.  
  181.   return new octave_integer (v1.integer_value () * v2.integer_value ());
  182. }
  183.  
  184. static octave_value
  185. div (const octave_value& a1, const octave_value& a2)
  186. {
  187.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  188.  
  189.   int d = v2.integer_value ();
  190.  
  191.   if (d == 0)
  192.     gripe_divide_by_zero ();
  193.  
  194.   return new octave_integer (v1.integer_value () / d);
  195. }
  196.  
  197. static octave_value
  198. i_s_div (const octave_value& a1, const octave_value& a2)
  199. {
  200.   CAST_BINOP_ARGS (const octave_integer&, const octave_scalar&);
  201.  
  202.   double d = v2.double_value ();
  203.  
  204.   if (d == 0.0)
  205.     gripe_divide_by_zero ();
  206.  
  207.   return new octave_scalar (v1.double_value () / d);
  208. }
  209.  
  210. static octave_value
  211. ldiv (const octave_value& a1, const octave_value& a2)
  212. {
  213.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  214.  
  215.   int d = v1.integer_value ();
  216.  
  217.   if (d == 0)
  218.     gripe_divide_by_zero ();
  219.  
  220.   return new octave_integer (v2.integer_value () / d);
  221. }
  222.  
  223. static octave_value
  224. lt (const octave_value& a1, const octave_value& a2)
  225. {
  226.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  227.  
  228.   return new octave_integer (v1.integer_value () < v2.integer_value ());
  229. }
  230.  
  231. static octave_value
  232. le (const octave_value& a1, const octave_value& a2)
  233. {
  234.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  235.  
  236.   return new octave_integer (v1.integer_value () <= v2.integer_value ());
  237. }
  238.  
  239. static octave_value
  240. eq (const octave_value& a1, const octave_value& a2)
  241. {
  242.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  243.  
  244.   return new octave_integer (v1.integer_value () == v2.integer_value ());
  245. }
  246.  
  247. static octave_value
  248. ge (const octave_value& a1, const octave_value& a2)
  249. {
  250.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  251.  
  252.   return new octave_integer (v1.integer_value () >= v2.integer_value ());
  253. }
  254.  
  255. static octave_value
  256. gt (const octave_value& a1, const octave_value& a2)
  257. {
  258.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  259.  
  260.   return new octave_integer (v1.integer_value () > v2.integer_value ());
  261. }
  262.  
  263. static octave_value
  264. ne (const octave_value& a1, const octave_value& a2)
  265. {
  266.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  267.  
  268.   return new octave_integer (v1.integer_value () != v2.integer_value ());
  269. }
  270.  
  271. static octave_value
  272. el_mul (const octave_value& a1, const octave_value& a2)
  273. {
  274.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  275.  
  276.   return new octave_integer (v1.integer_value () * v2.integer_value ());
  277. }
  278.  
  279. static octave_value
  280. el_div (const octave_value& a1, const octave_value& a2)
  281. {
  282.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  283.  
  284.   int d = v2.integer_value ();
  285.  
  286.   if (d == 0)
  287.     gripe_divide_by_zero ();
  288.  
  289.   return new octave_integer (v1.integer_value () / d);
  290. }
  291.  
  292. static octave_value
  293. el_ldiv (const octave_value& a1, const octave_value& a2)
  294. {
  295.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  296.  
  297.   int d = v1.integer_value ();
  298.  
  299.   if (d == 0)
  300.     gripe_divide_by_zero ();
  301.  
  302.   return new octave_integer (v2.integer_value () / d);
  303. }
  304.  
  305. static octave_value
  306. el_and (const octave_value& a1, const octave_value& a2)
  307. {
  308.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  309.  
  310.   return new octave_integer (v1.integer_value () && v2.integer_value ());
  311. }
  312.  
  313. static octave_value
  314. el_or (const octave_value& a1, const octave_value& a2)
  315. {
  316.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  317.  
  318.   return new octave_integer (v1.integer_value () || v2.integer_value ());
  319. }
  320.  
  321. DEFUN_DLD (make_int, args, ,
  322.   "int_val = make_int (val)\n\
  323. \n\
  324. Creates an integer variable from VAL.")
  325. {
  326.   static bool type_loaded = false;
  327.  
  328.   if (! type_loaded)
  329.     {
  330.       octave_integer::register_type ();
  331.  
  332.       cerr << "installing integer type at type-id = "
  333.        << octave_integer::static_type_id () << "\n";
  334.  
  335.       INSTALL_BINOP (add, octave_integer, octave_integer, add);
  336.       INSTALL_BINOP (sub, octave_integer, octave_integer, sub);
  337.       INSTALL_BINOP (mul, octave_integer, octave_integer, mul);
  338.       INSTALL_BINOP (div, octave_integer, octave_integer, div);
  339.       INSTALL_BINOP (ldiv, octave_integer, octave_integer, ldiv);
  340.       INSTALL_BINOP (lt, octave_integer, octave_integer, lt);
  341.       INSTALL_BINOP (le, octave_integer, octave_integer, le);
  342.       INSTALL_BINOP (eq, octave_integer, octave_integer, eq);
  343.       INSTALL_BINOP (ge, octave_integer, octave_integer, ge);
  344.       INSTALL_BINOP (gt, octave_integer, octave_integer, gt);
  345.       INSTALL_BINOP (ne, octave_integer, octave_integer, ne);
  346.       INSTALL_BINOP (el_mul, octave_integer, octave_integer, el_mul);
  347.       INSTALL_BINOP (el_div, octave_integer, octave_integer, el_div);
  348.       INSTALL_BINOP (el_ldiv, octave_integer, octave_integer, el_ldiv);
  349.       INSTALL_BINOP (el_and, octave_integer, octave_integer, el_and);
  350.       INSTALL_BINOP (el_or, octave_integer, octave_integer, el_or);
  351.  
  352.       INSTALL_BINOP (div, octave_integer, octave_scalar, i_s_div);
  353.     }
  354.  
  355.   octave_value retval;
  356.  
  357.   if (args.length () == 1)
  358.     {
  359.       double d = args(0).double_value ();
  360.  
  361.       if (! error_state)
  362.     retval = octave_value (new octave_integer (NINT (d)));
  363.     }
  364.   else
  365.     usage ("make_int");
  366.  
  367.   return retval;
  368. }
  369.  
  370. /*
  371. ;;; Local Variables: ***
  372. ;;; mode: C++ ***
  373. ;;; End: ***
  374. */
  375.